{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"NLU_training_multi_token_label_text_classifier_stackoverflow_tags.ipynb","provenance":[],"collapsed_sections":[]},"kernelspec":{"display_name":"Python 3","name":"python3"}},"cells":[{"cell_type":"markdown","metadata":{"id":"zkufh760uvF3"},"source":["![JohnSnowLabs](https://nlp.johnsnowlabs.com/assets/images/logo.png)\n","\n","[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/nlu/blob/master/examples/colab/Training/multi_label_text_classification/NLU_training_multi_token_label_text_classifier_stackoverflow_tags.ipynb)\n","\n","\n","\n","# Training a Deep Learning Classifier for sentences with multiple classes at the same time \n","MultiClassifierDL is a Multi-label Text Classification. MultiClassifierDL uses a Bidirectional GRU with Convolution model that we have built inside TensorFlow and supports up to 100 classes. The input to MultiClassifierDL is Sentence Embeddings such as state-of-the-art UniversalSentenceEncoder, BertSentenceEmbeddings, or SentenceEmbeddings\n","\n","\n","\n","### Multi ClassifierDL (Multi-class Text Classification with multiple classes per sentence)\n","With the [ClassifierDL model](https://nlp.johnsnowlabs.com/docs/en/annotators#multiclassifierdl-multi-label-text-classification) from Spark NLP you can achieve State Of the Art results on any multi class text classification problem \n","\n","This notebook showcases the following features : \n","\n","- How to train the deep learning classifier\n","- How to store a pipeline to disk\n","- How to load the pipeline from disk (Enables NLU offline mode)\n","\n"]},{"cell_type":"markdown","metadata":{"id":"dur2drhW5Rvi"},"source":["# 1. Install Java 8 and NLU"]},{"cell_type":"code","metadata":{"id":"hFGnBCHavltY"},"source":["!wget https://setup.johnsnowlabs.com/nlu/colab.sh -O - | bash\n","  \n","\n","import nlu"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"f4KkTfnR5Ugg"},"source":["# 2 Download sample dataset 60k Stack Overflow Questions with Quality Rating\n","\n","\n","https://www.kaggle.com/imoore/60k-stack-overflow-questions-with-quality-rate"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"y4xSRWIhwT28","outputId":"f7ac934c-b18f-4ffd-d773-842c81b2a80a"},"source":["import pandas as pd\n","! wget -N https://ckl-it.de/wp-content/uploads/2020/11/60kstackoverflow.csv -P /tmp\n","test_path = '/tmp/60kstackoverflow.csv'\n","train_df = pd.read_csv(test_path)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["--2021-01-02 11:20:29--  https://ckl-it.de/wp-content/uploads/2020/11/60kstackoverflow.csv\n","Resolving ckl-it.de (ckl-it.de)... 217.160.0.108, 2001:8d8:100f:f000::209\n","Connecting to ckl-it.de (ckl-it.de)|217.160.0.108|:443... connected.\n","HTTP request sent, awaiting response... 200 OK\n","Length: 50356825 (48M) [text/csv]\n","Saving to: ‘/tmp/60kstackoverflow.csv’\n","\n","60kstackoverflow.cs 100%[===================>]  48.02M  2.57MB/s    in 21s     \n","\n","2021-01-02 11:20:51 (2.32 MB/s) - ‘/tmp/60kstackoverflow.csv’ saved [50356825/50356825]\n","\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"gBxgVIB787wd"},"source":["# Split labels and clean them.\n","import pandas as pd\n","\n","train_df = pd.read_csv(test_path)\n","\n","f = lambda x : x.replace('<','').replace('>','')\n","g = lambda l : list(map(f,l))\n","train_df['y'] = train_df.Tags.str.split('><').map(g).str.join(',')\n","train_df['text'] = train_df['Title']\n","\n"," \n","# train_df = train_df.iloc[:50]"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":430},"id":"OfMCrNk-L_pq","outputId":"6ce7798d-ff2f-4b02-a066-67497ba0bdfa"},"source":["counts = train_df.explode('y').y.value_counts()\n","counts.iloc[0:100].plot.bar(figsize=(40,8), title='Distribution of Label Tags in Dataset')"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["<matplotlib.axes._subplots.AxesSubplot at 0x7f977030b278>"]},"metadata":{"tags":[]},"execution_count":4},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 2880x576 with 1 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":573},"id":"73UChGrePhr1","outputId":"af8b97e5-cec0-469e-c55d-433364ee31a5"},"source":["exp = train_df.y.str.split(',').explode().value_counts()\n","top_100_tags = list(exp[0:25].index)\n","# z = lambda r : True if r.split(',') in top_100_tags else False\n","z = lambda r : True if all(x in top_100_tags for x in r.split(',') ) else False\n","top_100_idx = train_df.y.map(z)\n","train_df = train_df[top_100_idx]\n","train_df"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>Id</th>\n","      <th>Title</th>\n","      <th>Body</th>\n","      <th>Tags</th>\n","      <th>CreationDate</th>\n","      <th>Y</th>\n","      <th>y</th>\n","      <th>text</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>13</th>\n","      <td>34556906</td>\n","      <td>output FILE ,is this a fault?</td>\n","      <td>\\r\\nmy code here\\r\\n\\r\\n        #include &lt;stdi...</td>\n","      <td>&lt;c++&gt;</td>\n","      <td>2016-01-01 14:20:01</td>\n","      <td>LQ_EDIT</td>\n","      <td>c++</td>\n","      <td>output FILE ,is this a fault?</td>\n","    </tr>\n","    <tr>\n","      <th>24</th>\n","      <td>34560768</td>\n","      <td>Can I throw from class init() in Swift with co...</td>\n","      <td>&lt;p&gt;I'd like my class &lt;em&gt;init()&lt;/em&gt; in Swift ...</td>\n","      <td>&lt;swift&gt;</td>\n","      <td>2016-01-01 22:42:24</td>\n","      <td>HQ</td>\n","      <td>swift</td>\n","      <td>Can I throw from class init() in Swift with co...</td>\n","    </tr>\n","    <tr>\n","      <th>25</th>\n","      <td>34560942</td>\n","      <td>C# - Count a specific word in richTextBox1 and...</td>\n","      <td>&lt;p&gt;I'm not sure, if this question is unique, b...</td>\n","      <td>&lt;c#&gt;</td>\n","      <td>2016-01-01 23:06:53</td>\n","      <td>LQ_CLOSE</td>\n","      <td>c#</td>\n","      <td>C# - Count a specific word in richTextBox1 and...</td>\n","    </tr>\n","    <tr>\n","      <th>30</th>\n","      <td>34562551</td>\n","      <td>c++ vector type function implemetation</td>\n","      <td>class City\\r\\n    {\\r\\n       private:\\r\\n...</td>\n","      <td>&lt;c++&gt;</td>\n","      <td>2016-01-02 04:17:27</td>\n","      <td>LQ_EDIT</td>\n","      <td>c++</td>\n","      <td>c++ vector type function implemetation</td>\n","    </tr>\n","    <tr>\n","      <th>48</th>\n","      <td>34566364</td>\n","      <td>japanese and portuguese language cannot support</td>\n","      <td>My site Japanese supported. But Portuguese  la...</td>\n","      <td>&lt;php&gt;</td>\n","      <td>2016-01-02 13:20:49</td>\n","      <td>LQ_EDIT</td>\n","      <td>php</td>\n","      <td>japanese and portuguese language cannot support</td>\n","    </tr>\n","    <tr>\n","      <th>...</th>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","    </tr>\n","    <tr>\n","      <th>44992</th>\n","      <td>60458575</td>\n","      <td>MySQL how to query five tables in one SELECT</td>\n","      <td>&lt;p&gt;I have 5 tables as follows:&lt;/p&gt;\\n\\n&lt;ul&gt;\\n&lt;l...</td>\n","      <td>&lt;mysql&gt;</td>\n","      <td>2020-02-28 20:07:09</td>\n","      <td>LQ_CLOSE</td>\n","      <td>mysql</td>\n","      <td>MySQL how to query five tables in one SELECT</td>\n","    </tr>\n","    <tr>\n","      <th>44993</th>\n","      <td>60460748</td>\n","      <td>Copy value of list not reference</td>\n","      <td>&lt;p&gt;I have a list that i want to compare to aft...</td>\n","      <td>&lt;python&gt;</td>\n","      <td>2020-02-28 23:54:33</td>\n","      <td>LQ_CLOSE</td>\n","      <td>python</td>\n","      <td>Copy value of list not reference</td>\n","    </tr>\n","    <tr>\n","      <th>44994</th>\n","      <td>60461193</td>\n","      <td>Weird question, but how do I make a python scr...</td>\n","      <td>&lt;p&gt;Before you get confused, I am going to comp...</td>\n","      <td>&lt;python&gt;&lt;python-3.x&gt;</td>\n","      <td>2020-02-29 01:25:40</td>\n","      <td>LQ_CLOSE</td>\n","      <td>python,python-3.x</td>\n","      <td>Weird question, but how do I make a python scr...</td>\n","    </tr>\n","    <tr>\n","      <th>44996</th>\n","      <td>60461754</td>\n","      <td>Does Python execute code from the top or botto...</td>\n","      <td>&lt;p&gt;I am working on learning Python and was won...</td>\n","      <td>&lt;python&gt;</td>\n","      <td>2020-02-29 03:33:59</td>\n","      <td>LQ_CLOSE</td>\n","      <td>python</td>\n","      <td>Does Python execute code from the top or botto...</td>\n","    </tr>\n","    <tr>\n","      <th>44998</th>\n","      <td>60465318</td>\n","      <td>how to implement fill in the blank in Swift</td>\n","      <td>&lt;p&gt;\"I _____ any questions.\"&lt;/p&gt;\\n\\n&lt;p&gt;I want t...</td>\n","      <td>&lt;ios&gt;&lt;swift&gt;</td>\n","      <td>2020-02-29 12:50:43</td>\n","      <td>LQ_CLOSE</td>\n","      <td>ios,swift</td>\n","      <td>how to implement fill in the blank in Swift</td>\n","    </tr>\n","  </tbody>\n","</table>\n","<p>9968 rows × 8 columns</p>\n","</div>"],"text/plain":["             Id  ...                                               text\n","13     34556906  ...                      output FILE ,is this a fault?\n","24     34560768  ...  Can I throw from class init() in Swift with co...\n","25     34560942  ...  C# - Count a specific word in richTextBox1 and...\n","30     34562551  ...             c++ vector type function implemetation\n","48     34566364  ...    japanese and portuguese language cannot support\n","...         ...  ...                                                ...\n","44992  60458575  ...       MySQL how to query five tables in one SELECT\n","44993  60460748  ...                   Copy value of list not reference\n","44994  60461193  ...  Weird question, but how do I make a python scr...\n","44996  60461754  ...  Does Python execute code from the top or botto...\n","44998  60465318  ...        how to implement fill in the blank in Swift\n","\n","[9968 rows x 8 columns]"]},"metadata":{"tags":[]},"execution_count":5}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":653},"id":"e_z1IU-XT0a0","outputId":"dc80c79e-11a0-4e63-bd40-8d933dbbb6aa"},"source":["import nlu\n","# load a trainable pipeline by specifying the train  prefix \n","\n","unfitted_pipe = nlu.load('train.multi_classifier')\n","#configure epochs\n","unfitted_pipe['multi_classifier'].setMaxEpochs(100)\n","unfitted_pipe['multi_classifier'].setLr(0.005)      \n","#  fit it on a datset with label='y' and text columns. Labels seperated by ','\n","fitted_pipe = unfitted_pipe.fit(train_df[['y','text']], label_seperator=',')\n","\n","# predict with the trained pipeline on dataset and get predictions\n","preds = fitted_pipe.predict(train_df[['y','text']])\n","preds"],"execution_count":null,"outputs":[{"output_type":"stream","text":["tfhub_use download started this may take some time.\n","Approximate size to download 923.7 MB\n","[OK!]\n"],"name":"stdout"},{"output_type":"execute_result","data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>y</th>\n","      <th>text</th>\n","      <th>multi_classifier_confidences</th>\n","      <th>sentence</th>\n","      <th>default_name_embeddings</th>\n","      <th>multi_classifier_classes</th>\n","    </tr>\n","    <tr>\n","      <th>origin_index</th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>13</th>\n","      <td>c++</td>\n","      <td>output FILE ,is this a fault?</td>\n","      <td>[]</td>\n","      <td>output FILE ,is this a fault?</td>\n","      <td>[0.04620636999607086, -0.04046135023236275, -0...</td>\n","      <td>[]</td>\n","    </tr>\n","    <tr>\n","      <th>24</th>\n","      <td>swift</td>\n","      <td>Can I throw from class init() in Swift with co...</td>\n","      <td>[0.86285734, 0.98327714]</td>\n","      <td>Can I throw from class init() in Swift with co...</td>\n","      <td>[0.053270746022462845, -0.00784565694630146, -...</td>\n","      <td>[swift, c]</td>\n","    </tr>\n","    <tr>\n","      <th>25</th>\n","      <td>c#</td>\n","      <td>C# - Count a specific word in richTextBox1 and...</td>\n","      <td>[0.64955217]</td>\n","      <td>C# - Count a specific word in richTextBox1 and...</td>\n","      <td>[-0.005682709161192179, -0.023547030985355377,...</td>\n","      <td>[regex]</td>\n","    </tr>\n","    <tr>\n","      <th>30</th>\n","      <td>c++</td>\n","      <td>c++ vector type function implemetation</td>\n","      <td>[0.9755105, 0.77180904, 0.9789763]</td>\n","      <td>c++ vector type function implemetation</td>\n","      <td>[0.024628309532999992, -0.015623562969267368, ...</td>\n","      <td>[c++, python-3.x, python]</td>\n","    </tr>\n","    <tr>\n","      <th>48</th>\n","      <td>php</td>\n","      <td>japanese and portuguese language cannot support</td>\n","      <td>[0.55255216]</td>\n","      <td>japanese and portuguese language cannot support</td>\n","      <td>[0.038325726985931396, -0.005848723463714123, ...</td>\n","      <td>[php]</td>\n","    </tr>\n","    <tr>\n","      <th>...</th>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","    </tr>\n","    <tr>\n","      <th>44992</th>\n","      <td>mysql</td>\n","      <td>MySQL how to query five tables in one SELECT</td>\n","      <td>[0.6404308, 0.99544823]</td>\n","      <td>MySQL how to query five tables in one SELECT</td>\n","      <td>[0.006962132174521685, -0.03580842167139053, -...</td>\n","      <td>[sql, mysql]</td>\n","    </tr>\n","    <tr>\n","      <th>44993</th>\n","      <td>python</td>\n","      <td>Copy value of list not reference</td>\n","      <td>[0.591653]</td>\n","      <td>Copy value of list not reference</td>\n","      <td>[0.025995030999183655, 0.001833591377362609, -...</td>\n","      <td>[javascript]</td>\n","    </tr>\n","    <tr>\n","      <th>44994</th>\n","      <td>python,python-3.x</td>\n","      <td>Weird question, but how do I make a python scr...</td>\n","      <td>[0.7427199, 0.99999976, 0.70473063, 0.72811186...</td>\n","      <td>Weird question, but how do I make a python scr...</td>\n","      <td>[0.018493961542844772, -0.04660267382860184, -...</td>\n","      <td>[html, python, javascript, node.js, php]</td>\n","    </tr>\n","    <tr>\n","      <th>44996</th>\n","      <td>python</td>\n","      <td>Does Python execute code from the top or botto...</td>\n","      <td>[0.9977689, 0.794142]</td>\n","      <td>Does Python execute code from the top or botto...</td>\n","      <td>[0.01413149293512106, -0.02844131551682949, -0...</td>\n","      <td>[python, php]</td>\n","    </tr>\n","    <tr>\n","      <th>44998</th>\n","      <td>ios,swift</td>\n","      <td>how to implement fill in the blank in Swift</td>\n","      <td>[0.9999993]</td>\n","      <td>how to implement fill in the blank in Swift</td>\n","      <td>[0.019475314766168594, -0.022571099922060966, ...</td>\n","      <td>[swift]</td>\n","    </tr>\n","  </tbody>\n","</table>\n","<p>10944 rows × 6 columns</p>\n","</div>"],"text/plain":["                              y  ...                  multi_classifier_classes\n","origin_index                     ...                                          \n","13                          c++  ...                                        []\n","24                        swift  ...                                [swift, c]\n","25                           c#  ...                                   [regex]\n","30                          c++  ...                 [c++, python-3.x, python]\n","48                          php  ...                                     [php]\n","...                         ...  ...                                       ...\n","44992                     mysql  ...                              [sql, mysql]\n","44993                    python  ...                              [javascript]\n","44994         python,python-3.x  ...  [html, python, javascript, node.js, php]\n","44996                    python  ...                             [python, php]\n","44998                 ios,swift  ...                                   [swift]\n","\n","[10944 rows x 6 columns]"]},"metadata":{"tags":[]},"execution_count":6}]},{"cell_type":"markdown","metadata":{"id":"DL_5aY9b3jSd"},"source":["# 4. Evaluate the model"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"0YDA2KunCeqQ","outputId":"8f72b51d-8e4c-49e8-884e-af5b0fdfa1ac"},"source":["from sklearn.preprocessing import MultiLabelBinarizer\n","from sklearn.metrics import classification_report\n","from sklearn.metrics import f1_score\n","from sklearn.metrics import roc_auc_score\n","mlb = MultiLabelBinarizer()\n","mlb = mlb.fit(preds.y.str.split(','))\n","y_true = mlb.transform(preds['y'].str.split(','))\n","y_pred = mlb.transform(preds.multi_classifier_classes.str.join(',').str.split(','))\n","print(\"Classification report: \\n\", (classification_report(y_true, y_pred)))\n","print(\"F1 micro averaging:\",(f1_score(y_true, y_pred, average='micro')))\n","print(\"ROC: \",(roc_auc_score(y_true, y_pred, average=\"micro\")))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Classification report: \n","               precision    recall  f1-score   support\n","\n","           0       0.67      0.80      0.73       840\n","           1       0.22      0.62      0.32       237\n","           2       0.37      0.47      0.41       467\n","           3       0.38      0.67      0.49       561\n","           4       0.48      0.54      0.51       831\n","           5       0.54      0.58      0.56       697\n","           6       0.49      0.73      0.59       792\n","           7       0.58      0.39      0.47      1352\n","           8       0.20      0.18      0.19       158\n","           9       0.49      0.77      0.60      1431\n","          10       0.57      0.75      0.65      2343\n","          11       0.36      0.56      0.43       833\n","          12       0.34      0.24      0.28       300\n","          13       0.51      0.74      0.60       539\n","          14       0.19      0.28      0.23       106\n","          15       0.63      0.67      0.65      1283\n","          16       0.61      0.74      0.67      1402\n","          17       0.21      0.25      0.23       411\n","          18       0.38      0.47      0.42       261\n","          19       0.90      0.10      0.19       183\n","          20       0.56      0.75      0.64       451\n","          21       0.56      0.73      0.63       485\n","          22       0.45      0.60      0.51       340\n","          23       0.34      0.13      0.19       220\n","          24       0.53      0.73      0.61       268\n","\n","   micro avg       0.50      0.63      0.56     16791\n","   macro avg       0.46      0.54      0.47     16791\n","weighted avg       0.51      0.63      0.55     16791\n"," samples avg       0.54      0.65      0.55     16791\n","\n","F1 micro averaging: 0.5556585043017869\n","ROC:  0.7920968190895907\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"mhFKVN93o1ZO"},"source":["# 5. Lets try different Sentence Emebddings"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"CzJd8omao0gt","outputId":"c3903ffc-ee61-47c1-87cf-bb1876436e25"},"source":["# We can use nlu.print_components(action='embed_sentence') to see every possibler sentence embedding we could use. Lets use bert!\n","nlu.print_components(action='embed_sentence')"],"execution_count":null,"outputs":[{"output_type":"stream","text":["For language <en> NLU provides the following Models : \n","nlu.load('en.embed_sentence') returns Spark NLP model tfhub_use\n","nlu.load('en.embed_sentence.use') returns Spark NLP model tfhub_use\n","nlu.load('en.embed_sentence.tfhub_use') returns Spark NLP model tfhub_use\n","nlu.load('en.embed_sentence.use.lg') returns Spark NLP model tfhub_use_lg\n","nlu.load('en.embed_sentence.tfhub_use.lg') returns Spark NLP model tfhub_use_lg\n","nlu.load('en.embed_sentence.albert') returns Spark NLP model albert_base_uncased\n","nlu.load('en.embed_sentence.electra') returns Spark NLP model sent_electra_small_uncased\n","nlu.load('en.embed_sentence.electra_small_uncased') returns Spark NLP model sent_electra_small_uncased\n","nlu.load('en.embed_sentence.electra_base_uncased') returns Spark NLP model sent_electra_base_uncased\n","nlu.load('en.embed_sentence.electra_large_uncased') returns Spark NLP model sent_electra_large_uncased\n","nlu.load('en.embed_sentence.bert') returns Spark NLP model sent_bert_base_uncased\n","nlu.load('en.embed_sentence.bert_base_uncased') returns Spark NLP model sent_bert_base_uncased\n","nlu.load('en.embed_sentence.bert_base_cased') returns Spark NLP model sent_bert_base_cased\n","nlu.load('en.embed_sentence.bert_large_uncased') returns Spark NLP model sent_bert_large_uncased\n","nlu.load('en.embed_sentence.bert_large_cased') returns Spark NLP model sent_bert_large_cased\n","nlu.load('en.embed_sentence.biobert.pubmed_base_cased') returns Spark NLP model sent_biobert_pubmed_base_cased\n","nlu.load('en.embed_sentence.biobert.pubmed_large_cased') returns Spark NLP model sent_biobert_pubmed_large_cased\n","nlu.load('en.embed_sentence.biobert.pmc_base_cased') returns Spark NLP model sent_biobert_pmc_base_cased\n","nlu.load('en.embed_sentence.biobert.pubmed_pmc_base_cased') returns Spark NLP model sent_biobert_pubmed_pmc_base_cased\n","nlu.load('en.embed_sentence.biobert.clinical_base_cased') returns Spark NLP model sent_biobert_clinical_base_cased\n","nlu.load('en.embed_sentence.biobert.discharge_base_cased') returns Spark NLP model sent_biobert_discharge_base_cased\n","nlu.load('en.embed_sentence.covidbert.large_uncased') returns Spark NLP model sent_covidbert_large_uncased\n","nlu.load('en.embed_sentence.small_bert_L2_128') returns Spark NLP model sent_small_bert_L2_128\n","nlu.load('en.embed_sentence.small_bert_L4_128') returns Spark NLP model sent_small_bert_L4_128\n","nlu.load('en.embed_sentence.small_bert_L6_128') returns Spark NLP model sent_small_bert_L6_128\n","nlu.load('en.embed_sentence.small_bert_L8_128') returns Spark NLP model sent_small_bert_L8_128\n","nlu.load('en.embed_sentence.small_bert_L10_128') returns Spark NLP model sent_small_bert_L10_128\n","nlu.load('en.embed_sentence.small_bert_L12_128') returns Spark NLP model sent_small_bert_L12_128\n","nlu.load('en.embed_sentence.small_bert_L2_256') returns Spark NLP model sent_small_bert_L2_256\n","nlu.load('en.embed_sentence.small_bert_L4_256') returns Spark NLP model sent_small_bert_L4_256\n","nlu.load('en.embed_sentence.small_bert_L6_256') returns Spark NLP model sent_small_bert_L6_256\n","nlu.load('en.embed_sentence.small_bert_L8_256') returns Spark NLP model sent_small_bert_L8_256\n","nlu.load('en.embed_sentence.small_bert_L10_256') returns Spark NLP model sent_small_bert_L10_256\n","nlu.load('en.embed_sentence.small_bert_L12_256') returns Spark NLP model sent_small_bert_L12_256\n","nlu.load('en.embed_sentence.small_bert_L2_512') returns Spark NLP model sent_small_bert_L2_512\n","nlu.load('en.embed_sentence.small_bert_L4_512') returns Spark NLP model sent_small_bert_L4_512\n","nlu.load('en.embed_sentence.small_bert_L6_512') returns Spark NLP model sent_small_bert_L6_512\n","nlu.load('en.embed_sentence.small_bert_L8_512') returns Spark NLP model sent_small_bert_L8_512\n","nlu.load('en.embed_sentence.small_bert_L10_512') returns Spark NLP model sent_small_bert_L10_512\n","nlu.load('en.embed_sentence.small_bert_L12_512') returns Spark NLP model sent_small_bert_L12_512\n","nlu.load('en.embed_sentence.small_bert_L2_768') returns Spark NLP model sent_small_bert_L2_768\n","nlu.load('en.embed_sentence.small_bert_L4_768') returns Spark NLP model sent_small_bert_L4_768\n","nlu.load('en.embed_sentence.small_bert_L6_768') returns Spark NLP model sent_small_bert_L6_768\n","nlu.load('en.embed_sentence.small_bert_L8_768') returns Spark NLP model sent_small_bert_L8_768\n","nlu.load('en.embed_sentence.small_bert_L10_768') returns Spark NLP model sent_small_bert_L10_768\n","nlu.load('en.embed_sentence.small_bert_L12_768') returns Spark NLP model sent_small_bert_L12_768\n","For language <fi> NLU provides the following Models : \n","nlu.load('fi.embed_sentence') returns Spark NLP model sent_bert_finnish_cased\n","nlu.load('fi.embed_sentence.bert.cased') returns Spark NLP model sent_bert_finnish_cased\n","nlu.load('fi.embed_sentence.bert.uncased') returns Spark NLP model sent_bert_finnish_uncased\n","For language <xx> NLU provides the following Models : \n","nlu.load('xx.embed_sentence') returns Spark NLP model sent_bert_multi_cased\n","nlu.load('xx.embed_sentence.bert') returns Spark NLP model sent_bert_multi_cased\n","nlu.load('xx.embed_sentence.bert.cased') returns Spark NLP model sent_bert_multi_cased\n","nlu.load('xx.embed_sentence.labse') returns Spark NLP model labse\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"0ofYHpu7sloS","outputId":"ea715585-daa2-433d-d281-02b9e61222a4"},"source":["pipe = nlu.load('en.embed_sentence.small_bert_L12_768 train.multi_classifier')\n","pipe.print_info()"],"execution_count":null,"outputs":[{"output_type":"stream","text":["sent_small_bert_L12_768 download started this may take some time.\n","Approximate size to download 392.9 MB\n","[OK!]\n","The following parameters are configurable for this NLU pipeline (You can copy paste the examples) :\n",">>> pipe['en_embed_sentence_small_bert_L12_768'] has settable params:\n","pipe['en_embed_sentence_small_bert_L12_768'].setBatchSize(32)  | Info: Batch size. Large values allows faster processing but requires more memory. | Currently set to : 32\n","pipe['en_embed_sentence_small_bert_L12_768'].setIsLong(False)  | Info: Use Long type instead of Int type for inputs buffer - Some Bert models require Long instead of Int. | Currently set to : False\n","pipe['en_embed_sentence_small_bert_L12_768'].setMaxSentenceLength(128)  | Info: Max sentence length to process | Currently set to : 128\n","pipe['en_embed_sentence_small_bert_L12_768'].setDimension(768)  | Info: Number of embedding dimensions | Currently set to : 768\n","pipe['en_embed_sentence_small_bert_L12_768'].setCaseSensitive(False)  | Info: whether to ignore case in tokens for embeddings matching | Currently set to : False\n","pipe['en_embed_sentence_small_bert_L12_768'].setStorageRef('sent_small_bert_L12_768')  | Info: unique reference name for identification | Currently set to : sent_small_bert_L12_768\n",">>> pipe['default_tokenizer'] has settable params:\n","pipe['default_tokenizer'].setTargetPattern('\\S+')   | Info: pattern to grab from text as token candidates. Defaults \\S+ | Currently set to : \\S+\n","pipe['default_tokenizer'].setContextChars(['.', ',', ';', ':', '!', '?', '*', '-', '(', ')', '\"', \"'\"])  | Info: character list used to separate from token boundaries | Currently set to : ['.', ',', ';', ':', '!', '?', '*', '-', '(', ')', '\"', \"'\"]\n","pipe['default_tokenizer'].setCaseSensitiveExceptions(True)  | Info: Whether to care for case sensitiveness in exceptions | Currently set to : True\n","pipe['default_tokenizer'].setMinLength(0)           | Info: Set the minimum allowed legth for each token | Currently set to : 0\n","pipe['default_tokenizer'].setMaxLength(99999)       | Info: Set the maximum allowed legth for each token | Currently set to : 99999\n",">>> pipe['sentence_detector'] has settable params:\n","pipe['sentence_detector'].setUseAbbreviations(True)  | Info: whether to apply abbreviations at sentence detection | Currently set to : True\n","pipe['sentence_detector'].setDetectLists(True)      | Info: whether detect lists during sentence detection | Currently set to : True\n","pipe['sentence_detector'].setUseCustomBoundsOnly(False)  | Info: Only utilize custom bounds in sentence detection | Currently set to : False\n","pipe['sentence_detector'].setCustomBounds([])       | Info: characters used to explicitly mark sentence bounds | Currently set to : []\n","pipe['sentence_detector'].setExplodeSentences(False)  | Info: whether to explode each sentence into a different row, for better parallelization. Defaults to false. | Currently set to : False\n","pipe['sentence_detector'].setMinLength(0)           | Info: Set the minimum allowed length for each sentence. | Currently set to : 0\n","pipe['sentence_detector'].setMaxLength(99999)       | Info: Set the maximum allowed length for each sentence | Currently set to : 99999\n",">>> pipe['document_assembler'] has settable params:\n","pipe['document_assembler'].setCleanupMode('shrink')  | Info: possible values: disabled, inplace, inplace_full, shrink, shrink_full, each, each_full, delete_full | Currently set to : shrink\n",">>> pipe['multi_classifier'] has settable params:\n","pipe['multi_classifier'].setMaxEpochs(2)            | Info: Maximum number of epochs to train | Currently set to : 2\n","pipe['multi_classifier'].setLr(0.001)               | Info: Learning Rate | Currently set to : 0.001\n","pipe['multi_classifier'].setBatchSize(64)           | Info: Batch size | Currently set to : 64\n","pipe['multi_classifier'].setValidationSplit(0.0)    | Info: Choose the proportion of training dataset to be validated against the model on each Epoch. The value should be between 0.0 and 1.0 and by default it is 0.0 and off. | Currently set to : 0.0\n","pipe['multi_classifier'].setThreshold(0.5)          | Info: The minimum threshold for each label to be accepted. Default is 0.5 | Currently set to : 0.5\n","pipe['multi_classifier'].setRandomSeed(44)          | Info: Random seed | Currently set to : 44\n","pipe['multi_classifier'].setShufflePerEpoch(False)  | Info: whether to shuffle the training data on each Epoch | Currently set to : False\n","pipe['multi_classifier'].setEnableOutputLogs(True)  | Info: Whether to use stdout in addition to Spark logs. | Currently set to : True\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":570},"id":"ABHLgirmG1n9","outputId":"60e9995e-080c-4213-cf03-c7baba89bd6a"},"source":["# Load pipe with bert embeds\n","# using large embeddings can take a few hours..\n","pipe['multi_classifier'].setMaxEpochs(120)            \n","pipe['multi_classifier'].setLr(0.0005)  \n","fitted_pipe = pipe.fit(train_df[['y','text']],label_seperator=',')\n","preds = fitted_pipe.predict(train_df[['y','text']])\n","preds"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div>\n","<style scoped>\n","    .dataframe tbody tr th:only-of-type {\n","        vertical-align: middle;\n","    }\n","\n","    .dataframe tbody tr th {\n","        vertical-align: top;\n","    }\n","\n","    .dataframe thead th {\n","        text-align: right;\n","    }\n","</style>\n","<table border=\"1\" class=\"dataframe\">\n","  <thead>\n","    <tr style=\"text-align: right;\">\n","      <th></th>\n","      <th>y</th>\n","      <th>text</th>\n","      <th>multi_classifier_confidences</th>\n","      <th>en_embed_sentence_small_bert_L12_768_embeddings</th>\n","      <th>document</th>\n","      <th>multi_classifier_classes</th>\n","    </tr>\n","    <tr>\n","      <th>origin_index</th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","      <th></th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>13</th>\n","      <td>c++</td>\n","      <td>output FILE ,is this a fault?</td>\n","      <td>[]</td>\n","      <td>[-0.0598912313580513, 0.429191917181015, -0.25...</td>\n","      <td>output FILE ,is this a fault?</td>\n","      <td>[]</td>\n","    </tr>\n","    <tr>\n","      <th>24</th>\n","      <td>swift</td>\n","      <td>Can I throw from class init() in Swift with co...</td>\n","      <td>[0.61310124]</td>\n","      <td>[-0.45358699560165405, 0.1986018270254135, -0....</td>\n","      <td>Can I throw from class init() in Swift with co...</td>\n","      <td>[java]</td>\n","    </tr>\n","    <tr>\n","      <th>25</th>\n","      <td>c#</td>\n","      <td>C# - Count a specific word in richTextBox1 and...</td>\n","      <td>[0.8172003]</td>\n","      <td>[-0.592096209526062, 0.0025841565802693367, -0...</td>\n","      <td>C# - Count a specific word in richTextBox1 and...</td>\n","      <td>[c#]</td>\n","    </tr>\n","    <tr>\n","      <th>30</th>\n","      <td>c++</td>\n","      <td>c++ vector type function implemetation</td>\n","      <td>[0.98100495]</td>\n","      <td>[-0.6645137071609497, 0.34700289368629456, 0.1...</td>\n","      <td>c++ vector type function implemetation</td>\n","      <td>[c++]</td>\n","    </tr>\n","    <tr>\n","      <th>48</th>\n","      <td>php</td>\n","      <td>japanese and portuguese language cannot support</td>\n","      <td>[]</td>\n","      <td>[-0.30820634961128235, 0.5732622742652893, 0.5...</td>\n","      <td>japanese and portuguese language cannot support</td>\n","      <td>[]</td>\n","    </tr>\n","    <tr>\n","      <th>...</th>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","      <td>...</td>\n","    </tr>\n","    <tr>\n","      <th>44992</th>\n","      <td>mysql</td>\n","      <td>MySQL how to query five tables in one SELECT</td>\n","      <td>[0.94582915]</td>\n","      <td>[-0.6759300231933594, 0.1323285549879074, 0.56...</td>\n","      <td>MySQL how to query five tables in one SELECT</td>\n","      <td>[mysql]</td>\n","    </tr>\n","    <tr>\n","      <th>44993</th>\n","      <td>python</td>\n","      <td>Copy value of list not reference</td>\n","      <td>[0.71518165]</td>\n","      <td>[-0.7307966947555542, 0.3146328032016754, -0.5...</td>\n","      <td>Copy value of list not reference</td>\n","      <td>[python]</td>\n","    </tr>\n","    <tr>\n","      <th>44994</th>\n","      <td>python,python-3.x</td>\n","      <td>Weird question, but how do I make a python scr...</td>\n","      <td>[0.9938545]</td>\n","      <td>[-0.478365957736969, -0.015336859039962292, 0....</td>\n","      <td>Weird question, but how do I make a python scr...</td>\n","      <td>[python]</td>\n","    </tr>\n","    <tr>\n","      <th>44996</th>\n","      <td>python</td>\n","      <td>Does Python execute code from the top or botto...</td>\n","      <td>[0.998447]</td>\n","      <td>[-0.7976136803627014, -0.17537403106689453, 0....</td>\n","      <td>Does Python execute code from the top or botto...</td>\n","      <td>[python]</td>\n","    </tr>\n","    <tr>\n","      <th>44998</th>\n","      <td>ios,swift</td>\n","      <td>how to implement fill in the blank in Swift</td>\n","      <td>[0.6266076, 0.9772264]</td>\n","      <td>[-0.4111633598804474, 0.04349775239825249, 0.2...</td>\n","      <td>how to implement fill in the blank in Swift</td>\n","      <td>[ios, swift]</td>\n","    </tr>\n","  </tbody>\n","</table>\n","<p>9968 rows × 6 columns</p>\n","</div>"],"text/plain":["                              y  ... multi_classifier_classes\n","origin_index                     ...                         \n","13                          c++  ...                       []\n","24                        swift  ...                   [java]\n","25                           c#  ...                     [c#]\n","30                          c++  ...                    [c++]\n","48                          php  ...                       []\n","...                         ...  ...                      ...\n","44992                     mysql  ...                  [mysql]\n","44993                    python  ...                 [python]\n","44994         python,python-3.x  ...                 [python]\n","44996                    python  ...                 [python]\n","44998                 ios,swift  ...             [ios, swift]\n","\n","[9968 rows x 6 columns]"]},"metadata":{"tags":[]},"execution_count":10}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"E7ah2LM6tIhG","outputId":"edaa6235-c8d2-474a-9cc1-331e0967086c"},"source":["from sklearn.preprocessing import MultiLabelBinarizer\n","from sklearn.metrics import classification_report\n","from sklearn.metrics import f1_score\n","from sklearn.metrics import roc_auc_score\n","mlb = MultiLabelBinarizer()\n","mlb = mlb.fit(preds.y.str.split(','))\n","y_true = mlb.transform(preds['y'].str.split(','))\n","y_pred = mlb.transform(preds.multi_classifier_classes.str.join(',').str.split(','))\n","print(\"Classification report: \\n\", (classification_report(y_true, y_pred)))\n","print(\"F1 micro averaging:\",(f1_score(y_true, y_pred, average='micro')))\n","print(\"ROC: \",(roc_auc_score(y_true, y_pred, average=\"micro\")))"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Classification report: \n","               precision    recall  f1-score   support\n","\n","           0       0.96      0.67      0.79       738\n","           1       0.95      0.71      0.82       228\n","           2       0.70      0.53      0.60       440\n","           3       0.91      0.63      0.75       508\n","           4       0.95      0.57      0.71       733\n","           5       0.91      0.58      0.71       621\n","           6       0.88      0.70      0.78       736\n","           7       0.81      0.65      0.72      1254\n","           8       0.86      0.58      0.69       145\n","           9       0.89      0.58      0.70      1288\n","          10       0.87      0.73      0.80      2164\n","          11       0.89      0.58      0.70       754\n","          12       0.84      0.67      0.74       277\n","          13       0.89      0.59      0.71       511\n","          14       0.96      0.27      0.42        96\n","          15       0.94      0.70      0.80      1193\n","          16       0.93      0.70      0.80      1265\n","          17       0.74      0.22      0.34       365\n","          18       0.97      0.70      0.82       246\n","          19       1.00      0.55      0.71       172\n","          20       0.92      0.71      0.81       427\n","          21       0.82      0.67      0.74       458\n","          22       0.81      0.66      0.73       319\n","          23       0.83      0.23      0.36       211\n","          24       0.97      0.64      0.77       242\n","\n","   micro avg       0.89      0.64      0.74     15391\n","   macro avg       0.89      0.59      0.70     15391\n","weighted avg       0.89      0.64      0.73     15391\n"," samples avg       0.70      0.64      0.65     15391\n","\n","F1 micro averaging: 0.7401884721644023\n","ROC:  0.8150061228796474\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"2BB-NwZUoHSe"},"source":["# 5. Lets save the model"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"eLex095goHwm","outputId":"bbf99f56-d4b1-4440-ecb7-fe9d61935c62"},"source":["stored_model_path = './models/multi_classifier_dl_trained' \n","fitted_pipe.save(stored_model_path)"],"execution_count":null,"outputs":[{"output_type":"stream","text":["Stored model in ./models/multi_classifier_dl_trained\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"e_b2DPd4rCiU"},"source":["# 6. Lets load the model from HDD.\n","This makes Offlien NLU usage possible!   \n","You need to call nlu.load(path=path_to_the_pipe) to load a model/pipeline from disk."]},{"cell_type":"code","metadata":{"id":"SO4uz45MoRgp"},"source":["hdd_pipe = nlu.load(path=stored_model_path)\n","\n","preds = hdd_pipe.predict('Tesla plans to invest 10M into the ML sector')\n","preds"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"e0CVlkk9v6Qi"},"source":["hdd_pipe.print_info()"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"M1LjAwJVJxun"},"source":[""],"execution_count":null,"outputs":[]}]}